home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Applications / Telnet 2.6.1d1 / src / source / network / MacTCP / network.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-16  |  28.8 KB  |  1,178 lines  |  [TEXT/KAHL]
  1. /****************************************************************
  2. *    NCSA Telnet for the Macintosh                                *
  3. *                                                                *
  4. *    National Center for Supercomputing Applications                *
  5. *    Software Development Group                                    *
  6. *    152 Computing Applications Building                            *
  7. *    605 E. Springfield Ave.                                        *
  8. *    Champaign, IL  61820                                        *
  9. *                                                                *
  10. *    Copyright (c) 1986-1993,                                    *
  11. *    Board of Trustees of the University of Illinois                *
  12. *****************************************************************
  13. *  Revisions:
  14. *  10/87  Initial source release, Tim Krauskopf
  15. *  2/88  typedef support for other compilers (TK)
  16. *  8/88  Gaige Paulsen - support for MacTCP drivers
  17. *  1/89  TK - conversion to new drivers, minor update for new calling convention
  18. *  6/89  TK - update to MacTCP 1.0 include files and use of GetMyIPAddr()
  19. *  7/92  Scott Bulmahn - add support for 2 global structs, put cursors into an array
  20. *  11/92 Jim Browne - Fixed more bugs than I care to mention.                    
  21. *
  22. */
  23.  
  24. #ifdef MPW
  25. #pragma segment Network
  26. #endif
  27.  
  28. #include "TelnetHeader.h"
  29. #include <TCPPB.h>
  30. #include <stdio.h>
  31. #include <String.h>
  32. #include "telneterrors.h"
  33. #include "InternalEvents.h"
  34. #include "maclook.proto.h"
  35. #include "menuseg.proto.h"
  36. #include "mainseg.proto.h"
  37. #include "getmyipaddr.h"    /* BYU LSC */
  38. #include "MyMacTCPstructures.h"
  39. #include "wind.h"
  40. #include "network.proto.h"
  41. #include "netevent.proto.h"
  42. #include "encrypt.proto.h"
  43. #include "DlogUtils.proto.h"    // For WriteZero
  44. #include "debug.h"
  45.  
  46. #ifdef THINK_C
  47. #pragma options(!profile)
  48. #endif
  49.  
  50. #ifdef __MWERKS__
  51. #pragma profile off
  52. #endif
  53.  
  54. //#define NET_DEBUG_MUCHINFO
  55. //#define    NET_DEBUG
  56. #ifdef    NET_DEBUG
  57. char    net_debug_string[256];
  58. #define    net_debug_print(x)    putln(net_debug_string)
  59. #else
  60. #define    net_debug_print(x)    
  61. #endif
  62.  
  63. pascal void Notify(StreamPtr streamPtr, unsigned short code, Ptr uptr, 
  64.                         unsigned short terminReason, struct ICMPReport *icmpMsg);
  65. PROTO_UPP(Notify, TCPNotify);
  66. static    TCPIOCompletionProc        OpenCompleteInit(TCPiopb *pbp);
  67. PROTO_UPP(OpenCompleteInit, TCPIOCompletion);
  68. static    TCPIOCompletionProc        CloseCompleteInit(TCPiopb *pbp);
  69. PROTO_UPP(CloseCompleteInit, TCPIOCompletion);
  70. static    TCPIOCompletionProc        SendCompleteInit(TCPiopb *pbp);
  71. PROTO_UPP(SendCompleteInit, TCPIOCompletion);
  72. static    void        OpenComplete(MyTCPpbPtr pbp);
  73. static    void        SendComplete(MyTCPpbPtr pbp);
  74. static    void        CloseComplete(MyTCPpbPtr pbp);
  75.  
  76. static    wdsEntry    *getSWDS(void);
  77. static    void        returnSWDS(wdsEntry *wds);
  78. static    void        MyPBreturn(MyTCPpbPtr pbp);
  79. static    MyTCPpb        *getPB(short driver,short call, StreamPtr stream, short usernum);
  80. static    void        clearPB(MyTCPpbPtr pbp, short driver, short call, StreamPtr stream);
  81. static    OSErr        xPBControlSync(MyTCPpbPtr pbp);
  82. static    OSErr        xPBControlAsync(MyTCPpbPtr pbp, TCPIOCompletionProc completion);
  83. static    short        makestream(void);
  84. static    void        reclaim(StreamRPtr p);
  85. static    short        giveback(StreamRPtr p, wdsEntry *wds);
  86. static    void        compressfds(wdsEntry *fds);
  87.  
  88. extern Cursor    *theCursors[];
  89. extern WindRec    *screens;
  90.  
  91. long        MyA5;
  92. short        TCPd = 0;                    /* refnum of TCP drivers */
  93. QHdr        gFreePBQueue;
  94. QHdr        gFreeSWDSQueue;
  95. short         numSWDS=0;                    /* Number of SWDS's ever alloc'd (PM Only) */
  96. StreamRPtr    streams[NPORTS];
  97. ip_port        nnfromport = 0;
  98.  
  99. /**************************************************************************/
  100. wdsEntry    *getSWDS(void)
  101. {
  102.     short        n=0;
  103.     wdsEntry *    wds;
  104.     
  105.     if (gFreeSWDSQueue.qHead == NULL)
  106.         wds = (wdsEntry *) NewPtrClear( sizeof(wdsEntry) * MAX_SWDS_ELEMS);    
  107.     else
  108.         {
  109.         wds = (wdsEntry *) gFreeSWDSQueue.qHead;
  110.         Dequeue(gFreeSWDSQueue.qHead, &gFreeSWDSQueue);
  111.         }
  112.         
  113.     if (wds == NULL) {    /* sorry, cant allocate WDS (BIG PROBLEM) */
  114.         DoError(508 | NET_ERRORCLASS, LEVEL3, NULL); // <- Is 508 correct?
  115.         forcequit();
  116.         // return ((wdsEntry*) 0L); <- ?? perhaps
  117.         }
  118.  
  119.     return(wds);
  120. }
  121.  
  122. /**************************************************************************/
  123. void    returnSWDS(wdsEntry *wds)
  124. {
  125.     Enqueue((QElemPtr)wds, &gFreeSWDSQueue);
  126. }
  127.  
  128. /**************************************************************************/
  129. void MyPBreturn(MyTCPpbPtr pbp)
  130. {
  131.     Enqueue((QElemPtr)pbp, &gFreePBQueue);
  132. }
  133.  
  134. /**************************************************************************/
  135. MyTCPpb *getPB(short driver,short call, StreamPtr stream, short usernum)
  136. {
  137.     #pragma unused (usernum)
  138.     MyTCPpb *pbp;
  139.  
  140.     if (gFreePBQueue.qHead == NULL)
  141.         pbp = (MyTCPpbPtr) NewPtrClear( sizeof(MyTCPpb) );
  142.     else
  143.         {
  144.         pbp = (MyTCPpbPtr) gFreePBQueue.qHead;
  145.         Dequeue(gFreePBQueue.qHead, &gFreePBQueue);
  146.         }
  147.         
  148.     if (pbp == NULL) {    /* sorry, cant allocate TCP buffer (BIG PROBLEM) */
  149.         DoError(508 | NET_ERRORCLASS, LEVEL3, NULL);
  150.         forcequit();
  151.         }
  152.     
  153.     memset((char *) pbp, '\0', sizeof(MyTCPpb));    
  154.     pbp->pb.ioCRefNum = driver;
  155.     pbp->pb.tcpStream = stream;
  156.     pbp->pb.csCode = call;
  157.     
  158.     return(pbp);
  159. }
  160.  
  161. /**************************************************************************/
  162. void clearPB(MyTCPpbPtr pbp, short driver, short call, StreamPtr stream)
  163. {
  164.     WriteZero((Ptr)pbp, sizeof(MyTCPpb));    /* BYU LSC - Default to all zeros */    
  165.     pbp->pb.ioCRefNum = driver;
  166.     pbp->pb.tcpStream = stream;
  167.     pbp->pb.csCode = call;
  168. }
  169.  
  170. /**************************************************************************/
  171. OSErr xPBControlSync(MyTCPpbPtr pbp) 
  172. { 
  173.     pbp->pb.ioCompletion = 0L;                         /* Charlie will puke if he ever sees */
  174.     return PBControl((ParmBlkPtr)(pbp),false);         /* his funtions here. -- JMB */
  175. }
  176.  
  177. /**************************************************************************/
  178. OSErr xPBControlAsync(MyTCPpbPtr pbp, TCPIOCompletionProc completion) 
  179. { 
  180. #ifndef __powerpc__
  181.     pbp->SavedA5 = MyA5;
  182. #endif
  183.     pbp->pb.ioCompletion = completion; 
  184.     return(PBControl((ParmBlkPtr)(pbp),true));        /* async */
  185. }
  186.  
  187. void    SetPortType(short port, short type)
  188. {
  189.     if (port >= 0 && port < NPORTS && (streams[port] != NULL))
  190.         streams[port]->portType = type;
  191. }
  192.  
  193. short    GetPortType(short port)
  194. {
  195.     if (port >= 0 && port < NPORTS && (streams[port] != NULL))
  196.         return(streams[port]->portType);
  197.     else return(-1);
  198. }
  199.  
  200. /**************************************************************************/
  201. /*    Returns an empty stream */ 
  202. short makestream(void)
  203. {
  204.     short        pnum, i;
  205.     StreamRPtr    p;
  206.     MyTCPpbPtr    pbp;
  207.  
  208.     for ( pnum=0; (streams[pnum]!= NULL) && pnum<NPORTS; pnum++);    /* BYU 2.4.16 */
  209.     
  210.     if (pnum >= NPORTS)
  211.         return(-2);
  212.  
  213.      if (!(p = streams[pnum] = (StreamRPtr) NewPtrClear(sizeof(StreamRec))))
  214.          return(-1);
  215.   
  216.      if ((p->buffer = (char *) NewPtrClear( TCPBUFSIZ)) == NULL) {
  217.          DisposePtr((Ptr)p);
  218.          streams[pnum] = 0;
  219.           return(-1);
  220.      }
  221.      if ((p->sbuffer = (char *) NewPtrClear( TCPBUFSIZ)) == NULL) {
  222.          DisposePtr((Ptr)p->buffer);
  223.          DisposePtr((Ptr)p);
  224.          streams[pnum] = 0;
  225.           return(-1);
  226.      }    
  227.  
  228.     
  229.     for (i=0; i<MAX_FDS_ELEMS; i++) 
  230.         {
  231.         p->fds[ i].length =0; p->fds[ i].ptr = 0L;
  232.         p->exFDS[ i].inuse=0; p->exFDS[ i].fds.length=0;p->exFDS[ i].fds.ptr=0L;
  233.         }
  234.     p->fds[0].length = TCPBUFSIZ;
  235.     p->fds[0].ptr = p->sbuffer;
  236.     p->maxFDSused=0;
  237.     p->edata = NULL;
  238.     
  239.     pbp=getPB( TCPd, TCPCreate, (long) 0, 7);    /* BYU LSC important - Make create call */
  240.     pbp->pb.csParam.create.rcvBuff = p->buffer;
  241.     pbp->pb.csParam.create.rcvBuffLen = TCPBUFSIZ;
  242.     pbp->pb.csParam.create.notifyProc = (TCPNotifyProc)NotifyUPP;
  243.  
  244.     if (xPBControlSync(pbp) != noError) 
  245.         DoError (512 | NET_ERRORCLASS, LEVEL2, NULL);
  246.  
  247.     p->stream = pbp->pb.tcpStream;
  248.     
  249.     net_debug_print("Made new stream");
  250.     MyPBreturn(pbp);
  251.     return(pnum);
  252. }
  253.  
  254. /**************************************************************************/
  255. /*    reclaim( p) -
  256.         reclaims buffer space to stream (from pointer p) into the FDS list  */
  257.  
  258. void reclaim(StreamRPtr p)
  259. {
  260.     short n=0, offset=0;
  261.     
  262.     while (offset < MAX_FDS_ELEMS && p->fds[offset].ptr != 0L) offset++;
  263.     
  264.     if (offset >= MAX_FDS_ELEMS) /* offset too large -- cant reclaim */        
  265.         return;
  266.         
  267.     for (n=0 ; n<MAX_FDS_ELEMS && offset< MAX_FDS_ELEMS; n++) 
  268.         {
  269.         if (p->exFDS[ n].inuse) 
  270.             {
  271.             p->fds[ offset++]=p->exFDS[ n].fds;
  272.             p->exFDS[ n].inuse = 0;
  273.             }
  274.         }
  275. }
  276.  
  277. /**************************************************************************
  278.     giveback( p, wds) - gives WDS entries back to the stream by putting them in the 
  279.          mutually exclusive buffer.
  280.     p -> stream
  281.     wds -> wds array            */
  282. short giveback(StreamRPtr p, wdsEntry *wds)
  283. {
  284.     short n=0, m=0;
  285.     
  286.     while ( n< MAX_SWDS_ELEMS && wds[n].ptr !=0L) 
  287.         {
  288.         while (m< MAX_FDS_ELEMS && p->exFDS[ m].inuse) m++;
  289.         if (m >= MAX_FDS_ELEMS)                                    // This was off by one - JMB 2.6
  290.             return(-1);                /* No room in the RECLAIMation center */
  291.         else 
  292.             {
  293.             p->exFDS[ m].inuse =1;
  294.             p->exFDS[ m].fds = wds[n];
  295.             m++;
  296.             }
  297.         n++;
  298.         }
  299. }
  300.  
  301. /**************************************************************************/
  302. /*    compressfds( fds)
  303.         compress an fds data structure to make everyone happy */
  304. void compressfds(wdsEntry *fds)
  305. {
  306.     short n,m,compressed;
  307.     
  308.     compressed = 0;
  309.     
  310.     while ( !compressed) {
  311.         compressed=1;
  312.         for (n=0; n< MAX_FDS_ELEMS; n++) 
  313.             {                /* Slow Forwards */
  314.             if (fds[n].ptr) 
  315.                 {                                /* Do if N exists */
  316.                 for ( m = MAX_FDS_ELEMS -1; m>=0; m--) 
  317.                     {    /* Fast Backwards */
  318.                     if (fds[m].ptr && (fds[m].ptr+fds[m].length == fds[n].ptr)) {
  319.                         fds[n].length+=fds[m].length;
  320.                         fds[n].ptr = fds[m].ptr;
  321.                         fds[m].ptr=0L;
  322.                         fds[m].length=0;
  323.                         compressed=0;
  324.                         }
  325. #ifdef CHECKBOTHWAYZ
  326.                     else 
  327.                     if (fds[n].ptr+fds[n].length == fds[m].ptr) 
  328.                         {
  329.                         fds[m].length+=fds[n].length;
  330.                         fds[n].ptr=0L;
  331.                         fds[n].length=0;
  332.                         compressed=0;
  333.                         }
  334. #endif CHECKBOTHWAYZ
  335.                     }
  336.                 }
  337.             }
  338.         }
  339.     m=0;n=0;
  340.     
  341.     /* Close the gaps */
  342.     
  343.     while (n+m < MAX_FDS_ELEMS) 
  344.         {
  345.         while (fds[n+m].ptr ==0L && n+m< MAX_FDS_ELEMS)
  346.             m++;            /* increase gap to valid entry */
  347.         if (n+m<MAX_FDS_ELEMS)
  348.             fds[n]=fds[n+m];
  349.         n++;
  350.         }
  351.     
  352.     /* Get rid of the empty spaces */
  353.     
  354.     n--;        /* for the next loop */
  355.     while (n < MAX_FDS_ELEMS)
  356.         {
  357.         fds[n].ptr=0;
  358.         fds[n++].length=0;
  359.         }
  360. }
  361.  
  362. /***************************************************************************/
  363. /*  Mnetread
  364. *   Read from a connection buffer into a user buffer.  
  365. *   Returns number of bytes read, < 0 on error
  366. * NOTE:
  367. *    current version very inefficient, but hopefully works.
  368. */
  369. short    netread(short pnum, void *buffer, short n)
  370. {
  371.     short        i;
  372.     StreamRPtr    p;
  373.     MyTCPpbPtr    pbp;
  374.     short        inQ, reqdamt;
  375.  
  376.     if (pnum < 0 || pnum >= NPORTS)            /* BYU 2.4.15 */
  377.         return(-2);
  378.  
  379.     if (NULL == (p = streams[pnum]))
  380.         return(-2);
  381.         
  382.     pbp=getPB( TCPd, TCPStatus, p->stream, 1);                /* Make status call */
  383.     if (xPBControlSync(pbp) != noError)                     /* status call bombed */
  384.         DoError (509 | NET_ERRORCLASS, LEVEL1, "Mnetread");
  385.  
  386.     if (pbp->pb.csParam.status.connectionState !=8) {
  387. #ifdef    NET_DEBUG
  388.         sprintf(net_debug_string, "CState: %d is %d",(int)pnum, (int)pbp->pb.csParam.status.connectionState);
  389.         net_debug_print(net_debug_string);
  390. #endif
  391.         MyPBreturn(pbp);
  392.         return(-1);                              /* Connection not established */
  393.         }
  394.     
  395.     inQ = pbp->pb.csParam.status.amtUnreadData;
  396.     reqdamt = n >inQ ? inQ : n;
  397.     
  398.     clearPB( pbp, TCPd, TCPRcv, p->stream);
  399.     pbp->pb.csParam.receive.rcvBuff = buffer;
  400.     pbp->pb.csParam.receive.rcvBuffLen = reqdamt;
  401.     
  402.     if (reqdamt<1) 
  403.         {                                /* Drop out if no data */
  404.         MyPBreturn(pbp);
  405.         return(0);
  406.         }
  407.     
  408.     if ((i = xPBControlSync(pbp)) != noError) {
  409.         DoError (524 | NET_ERRORCLASS, LEVEL1, NULL);
  410.         return(-1);
  411.         }
  412.         
  413.     reqdamt = pbp->pb.csParam.receive.rcvBuffLen;
  414.     if (reqdamt<inQ) 
  415.         netputuev( CONCLASS, CONDATA, pnum,0);            /* more data to get */
  416.  
  417.      /* Decrypt data */
  418.      if (p->edata && (((CDATA *)(p->edata))->decrypt_input)) {
  419.          unsigned char *cp = (unsigned char *)buffer;
  420.          short len = reqdamt;
  421.          
  422.          while (len-- > 0) {
  423.              *cp = (*((CDATA *)(p->edata))->decrypt_input)((CDATA *)p->edata, (int)(*cp));
  424.              cp++;
  425.          }        
  426.      }
  427.  
  428.     MyPBreturn(pbp);
  429.     return(reqdamt);
  430. }
  431.  
  432. /************************************************************************/
  433. /* netwrite
  434. *  write something into the output queue, netsleep routine will come
  435. *  around and send the data, etc.
  436. *
  437. */
  438. short    netwrite(short pnum, void *buffer, short nsend)
  439. {    
  440.     StreamRPtr    p;
  441.     wdsEntry    *swds;
  442.     short        remaining, queued, n,m;
  443.     MyTCPpbPtr    pbp;
  444.     OSErr        err;
  445.  
  446. #ifdef    NET_DEBUG_MUCHINFO
  447.     sprintf(net_debug_string, "port: %d\tbuffer: %lx\tnsend %d", pnum,
  448.         (unsigned int)buffer, (int)nsend);
  449.     net_debug_print(net_debug_string);
  450. #endif
  451.  
  452.     if (pnum < 0 || pnum >= NPORTS)        /* BYU 2.4.15 */
  453.         return(-2);
  454.  
  455.     if ( (p = streams[pnum]) == NULL)
  456.         return(-2);
  457.     
  458.     if ( !nsend )
  459.         return(0);
  460.  
  461.     swds = getSWDS();
  462.     
  463.     if (swds == NULL) return(nsend);        // Duh, Mr. Bulmahn. - JMB 2.6
  464.     
  465.     reclaim( p);
  466.  
  467.     compressfds( p->fds);
  468.  
  469.     n=0; remaining = nsend;
  470.  
  471. //    if (p->fds[0].ptr == 0) DebugStr("\pArgh! fds[0] is NULL!");
  472.     
  473.     while (p->fds[n].ptr !=0 && remaining>0 ) {
  474. //        if (n >= MAX_SWDS_ELEMS) DebugStr("\pOverflowing SWDS in while loop!");
  475.         
  476.         swds[n].ptr = p->fds[n].ptr;
  477.         if ( p->fds[n].length > remaining) {
  478.             swds[n].length = remaining;
  479.             p->fds[n].length -= remaining;
  480.             p->fds[n].ptr += remaining;
  481.             remaining=0;
  482.             }
  483.         else 
  484.             {
  485.             swds[n].length =  p->fds[n].length;
  486.             remaining -= p->fds[n].length;
  487.             p->fds[n].length = 0;
  488.             p->fds[n].ptr = 0;
  489.             }
  490.         n++;
  491.         }
  492.  
  493.     if (n>p->maxFDSused) p->maxFDSused=n;
  494.     
  495.     compressfds( p->fds);
  496.  
  497.     queued = nsend-remaining;
  498.     
  499.     for(m=0; m<n; m++) {
  500. #ifdef    NET_DEBUG_MUCHINFO
  501.     sprintf(net_debug_string, "swds[m].ptr: %lx\tswds[m].length: %d", (unsigned int)swds[m].ptr, (int)swds[m].length);
  502.     net_debug_print(net_debug_string);
  503. #endif
  504.         }
  505.         
  506.     for (m=0; m<n; m++) 
  507.         {
  508.         BlockMove(buffer, swds[m].ptr, swds[m].length);    /* BYU LSC - Put data in WDS */
  509.     
  510.         /*
  511.          * encrypt if encrypting the session
  512.          */
  513.          if (p->edata && ((CDATA *)p->edata)->encrypt_output)
  514.              (*((CDATA *)p->edata)->encrypt_output)((CDATA *)p->edata, (unsigned char *)swds[m].ptr, swds[m].length);
  515.  
  516.         buffer=(void *)((char *)buffer + swds[m].length);
  517.         }
  518.     
  519.     swds[m].ptr = 0L;
  520.     swds[m].length=0;
  521.     
  522.     pbp=getPB( TCPd, TCPSend, p->stream, 2);            /* Make send call */
  523.     pbp->pb.csParam.send.wdsPtr = (Ptr) swds;
  524.     pbp->pb.csParam.send.pushFlag = p->push;
  525.     p->push=0;
  526.  
  527.     if ((err = xPBControlAsync(pbp, (TCPIOCompletionProc)SendCompleteInitUPP)) != noError) 
  528.         {
  529.         char temp_xvvyz[256];
  530.         
  531.         sprintf(temp_xvvyz, "netwrite: %d", err);
  532.         DoError(510 | NET_ERRORCLASS, LEVEL2, temp_xvvyz);
  533.         return(-1);
  534.         }
  535.  
  536.     return(queued);
  537. }
  538.  
  539. /**************************************************************************/
  540. /*  Mnetpush
  541. *   attempt to push the rest of the data from the queue
  542. *   and then return whether the queue is empty or not (0 = empty)
  543. *   returns the number of bytes in the queue.
  544. */
  545. short netpush(short pnum)
  546. {
  547.     StreamRPtr    p;
  548.     MyTCPpbPtr    pbp;
  549.     short        inQ;
  550.     OSErr        err;
  551.  
  552.     if (pnum < 0 || pnum >= NPORTS)        /* BYU 2.4.15 */
  553.         return(-2);
  554.  
  555.     if (NULL == (p = streams[pnum]))
  556.         return(-2);
  557.  
  558.     pbp=getPB( TCPd, TCPStatus, p->stream, 3);            /* Make status call */
  559. //#ifdef    NET_DEBUG_MUCHINFO
  560. //    sprintf(net_debug_string, "TCPd == %d", TCPd);
  561. //    net_debug_print(net_debug_string);
  562. //#endif
  563.     if ((err = xPBControlSync(pbp)) != noError) {        /* status call bombed */
  564.         char temp_xvvyz[256];
  565.  
  566.         sprintf(temp_xvvyz, "netpush: %d", err);
  567.         DoError(509 | NET_ERRORCLASS, LEVEL2, temp_xvvyz);
  568.         }
  569.         
  570.     inQ = pbp->pb.csParam.status.amtUnackedData;
  571.     MyPBreturn( pbp);
  572.     
  573.     p->push=1;
  574.     return(inQ);
  575. }    
  576.  
  577. /**************************************************************************/
  578. /*  Mnetqlen
  579. *   return the number of bytes waiting to be read from the incoming queue.
  580. */
  581. short netqlen(short pnum)
  582. {
  583.     StreamRPtr    p;
  584.     MyTCPpbPtr    pbp;
  585.     short        inQ;
  586.  
  587.     if (pnum < 0 || pnum >= NPORTS)        /* BYU 2.4.15 */
  588.         return(-2);
  589.  
  590.     if (NULL == (p = streams[pnum]))
  591.         return(-2);
  592.  
  593.     pbp=getPB( TCPd, TCPStatus, p->stream, 4);                /* Make status call */
  594.     if (xPBControlSync(pbp) != noError)                     /* status call failed */
  595.         DoError(509 | NET_ERRORCLASS, LEVEL2, "Mnetqlen");
  596.  
  597.     inQ = pbp->pb.csParam.status.amtUnreadData;
  598.     MyPBreturn( pbp);
  599.     
  600.     p->push = 1;
  601.     return(inQ);
  602. }
  603.  
  604. /**************************************************************************/
  605. /*  Mnetroom()
  606. *    return how much room is available in output buffer for a connection
  607. */
  608. short netroom(short pnum)
  609. {
  610.     StreamRPtr    p;
  611.     short        inQ, n;
  612.  
  613.     if (pnum < 0 || pnum >= NPORTS)        /* BYU 2.4.15 */
  614.         return(-2);
  615.  
  616.     if (NULL == (p = streams[pnum]))
  617.         return(-2);
  618.  
  619.     reclaim( p);
  620.     compressfds( p->fds);
  621.  
  622. #ifdef OLDM
  623.     pbp=getPB( TCPd, TCPStatus, p->stream, 5);            /* Make status call */
  624.     if (xPBControlSync(pbp) != noError) 
  625.         DoError(509 | NET_ERRORCLASS, LEVEL1, "Mnetroom");
  626.  
  627.     inQ = pbp->csParam.status.sendWindow -
  628.                 pbp->csParam.status.amtUnackedData;
  629.     MyPBreturn( pbp);
  630. #else
  631. /*#pragma unused(pbp)    /* BYU LSC */
  632. #endif
  633.  
  634.     inQ = n = 0;
  635.     while (p->fds[n].ptr) {
  636.     
  637.         inQ += p->fds[n].length;                /* add up free list space */
  638.         n++;
  639.         }
  640.  
  641.     return(inQ);
  642. }
  643.  
  644. /**************************************************************************/
  645. void netgetip(unsigned char *st)
  646. {
  647.     struct GetAddrParamBlock mypb;
  648.     /* long netmask; */
  649.  
  650.     net_debug_print("Attempting getmyipaddr");
  651.     
  652.     WriteZero((Ptr)&mypb, sizeof(struct GetAddrParamBlock));
  653.     
  654.     mypb.ioCRefNum = TCPd;            /* BYU LSC - TCP driver has to be open by now */
  655.     mypb.csCode = ipctlGetAddr;
  656.  
  657.     if (PBControl((ParmBlkPtr)&mypb, false) != noError) 
  658.         {
  659.         DoError(511 | NET_ERRORCLASS, LEVEL2, NULL);
  660.         return;
  661.         }
  662.     
  663.     BlockMove(&mypb.ourAddress, st, 4);    /* BYU LSC - copy the address */
  664.     /* netmask is here if we want it, too */
  665. }
  666.  
  667. void netfromport            /* next "open" will use this port */
  668.   ( short port)
  669. {
  670.     nnfromport = (ip_port)port;
  671. }
  672.  
  673. /**************************************************************************/
  674. /*  Mnetest?
  675. *  is a particular session established yet?
  676. *  Returns 0 if the connection is in the established state.
  677. */
  678. short netest(short pnum)
  679. {
  680.     StreamRPtr    p;
  681.     MyTCPpbPtr    pbp;
  682.     short        inQ;
  683.  
  684.     if (pnum < 0 || pnum >= NPORTS)        /* BYU 2.4.15 */
  685.         return(-2);
  686.  
  687.     if (NULL == (p = streams[pnum]))
  688.         return(-2);
  689.  
  690.     pbp=getPB( TCPd, TCPStatus, p->stream, 6);            /* Make status call */
  691.     if (xPBControlSync(pbp) != noError)
  692.         {
  693.         DoError(509 | NET_ERRORCLASS, LEVEL2, "Mnetest");
  694.         inQ = -1;
  695.         }
  696.     else 
  697.         inQ = pbp->pb.csParam.status.connectionState !=8;
  698.     MyPBreturn( pbp);
  699.     
  700.     return(inQ);
  701. }
  702.  
  703. /**************************************************************************/
  704. /*  Mnetlisten
  705. *   Listen to a TCP port number and make the connection automatically when
  706. *   the SYN packet comes in.  The TCP layer will notify the higher layers
  707. *   with a CONOPEN event.  Save the port number returned to refer to this
  708. *   connection.
  709. *
  710. *   usage:   portnum = netlisten(service);
  711. *            short service;
  712. *
  713. */
  714.  
  715. short netlisten(ip_port serv)
  716. {
  717.     short        pnum;
  718.     StreamRPtr    p;
  719.     MyTCPpbPtr    pbp;
  720.  
  721.     pnum = makestream();
  722.  
  723.     if (pnum < 0 || pnum >= NPORTS)        /* BYU 2.4.15 */
  724.         return(-2);
  725.  
  726.     if (NULL == (p = streams[pnum]))
  727.         return(-2);
  728.  
  729.     pbp=getPB( TCPd, TCPPassiveOpen, p->stream, 8);            /* Make Listen call */
  730.     
  731.     pbp->pb.csParam.open.localPort = serv;
  732.     
  733.     if (xPBControlAsync(pbp, (TCPIOCompletionProc)OpenCompleteInitUPP) != noError) 
  734.         DoError(513 | NET_ERRORCLASS, LEVEL2, NULL);
  735.  
  736.     return(pnum);                        /* BYU 2.4.16 */
  737. }
  738.  
  739. /***********************************************************************/
  740. /*  Mnetgetftp
  741. *  Provides the information that ftp needs to open a stream back to the
  742. *  originator of the command connection.  The other side's IP number
  743. *  and the port numbers to be used to calculate the default data connection
  744. *  number.  Returns values in an integer array for convenient use in 
  745. *  PORT commands.
  746. */
  747. short    netgetftp(short pnum, ip_addr *addr, ip_port *localPort, ip_port *remotePort)
  748. {
  749.     StreamRPtr p;
  750.     MyTCPpbPtr pbp;
  751.     
  752.     if (pnum < 0)
  753.         return(-2);
  754.  
  755.     if (NULL == (p = streams[pnum]))
  756.         return(-2);
  757.  
  758.     pbp=getPB( TCPd, TCPStatus, p->stream, 9);            /* Make status call */
  759.     if (xPBControlSync(pbp) != noError) 
  760.         DoError(514 | NET_ERRORCLASS, LEVEL2, NULL);
  761.  
  762.     *addr = pbp->pb.csParam.status.remoteHost;
  763.     *localPort = pbp->pb.csParam.status.localPort;
  764.     *remotePort = pbp->pb.csParam.status.remotePort;
  765.     MyPBreturn( pbp);
  766. }
  767.  
  768. /**************************************************************************/
  769. /*  Open a network socket for the user. */
  770. short netxopen( ip_addr machine, ip_port service,
  771.                 short    timeout    )        // in seconds
  772. {
  773.     short        pnum;
  774.     StreamRPtr    p;
  775.     MyTCPpbPtr    pbp;
  776.  
  777.     pnum = makestream();
  778.  
  779.     if (pnum < 0)
  780.         return(-2);
  781.  
  782.     if (NULL == (p = streams[pnum]))
  783.         return(-2);
  784.  
  785.     pbp=getPB( TCPd, TCPActiveOpen, p->stream, 10);            /* Make Listen call */
  786.     
  787.     pbp->pb.csParam.open.remoteHost = machine;            /* IP # */
  788.     pbp->pb.csParam.open.remotePort = service;                /* Port */
  789.     pbp->pb.csParam.open.localPort = nnfromport;            /* My Port */
  790.     pbp->pb.csParam.open.ulpTimeoutValue = (byte)timeout;    // timeout value
  791.     pbp->pb.csParam.open.ulpTimeoutAction = 1;                // Abort
  792.     pbp->pb.csParam.open.validityFlags = 0xC0;                // Timeout and action are valid
  793.     nnfromport=0;                                            /* Next one is random */
  794.     
  795.     if (xPBControlAsync(pbp, (TCPIOCompletionProc)OpenCompleteInitUPP) != noError) {
  796.         DoError(515 | NET_ERRORCLASS, LEVEL2, NULL);
  797.         return(-1);
  798.         }
  799.     
  800.     SetPortType(pnum, NO_TYPE);                // Is allocated to the user
  801.     
  802. #ifdef    NET_DEBUG
  803.     sprintf(net_debug_string, "TCPOpen on port #%d", pnum);
  804.     net_debug_print(net_debug_string);
  805. #endif
  806.     return(pnum);                    /* BYU 2.4.16 */
  807. }
  808.  
  809.  
  810. /**************************************************************************/
  811. /* Mnetclose
  812. *  Do appropriate actions to return connection state to SCLOSED which
  813. *  enables the memory for that port to be reused.
  814. *
  815. *    Specifically:
  816. *        o If status is closed, then release the data structures
  817. *        o If status is not close, perform bkgrd close which generates CLOSEDONE,
  818. *            which should make the session layer call us again
  819. */
  820. short netclose(short pnum)
  821. {
  822.     StreamRPtr    p;
  823.     MyTCPpbPtr    pbp;
  824.     OSErr        errorCode;
  825.     short        status;
  826.     static        short count=0;
  827.  
  828.     errorCode = 0;
  829.     
  830.     if (pnum < 0 || pnum >= NPORTS)            /* is a valid port? */
  831.         return(-1);
  832.  
  833.     if ((p = streams[pnum]) == NULL)             /* nothing there */
  834.         return (1);
  835.  
  836.     pbp=getPB( TCPd, TCPStatus, p->stream, 11);            /* Make status call */
  837.     if ((errorCode = xPBControlSync(pbp)) != noError) 
  838.         {
  839.         if ( errorCode == invalidStreamPtr)
  840.             {
  841.             DoError (516 | NET_ERRORCLASS, LEVEL2, "Mnetclose");
  842.             return(-1);
  843.             }
  844.         else
  845.             {
  846.             status=0;
  847.             count =0;
  848.             }
  849.         }
  850.     else 
  851.         {
  852.         status = pbp->pb.csParam.status.connectionState;            /* The connection Status */
  853.         if (count++ ==10) 
  854.             {
  855.             status= 0;
  856.             count =0;
  857.             }
  858.         }
  859.  
  860. /* */
  861.  
  862. #ifdef    NET_DEBUG
  863.     sprintf(net_debug_string, "Mnetclose:error code=%i status=%d",(int)errorCode, status);
  864.     net_debug_print(net_debug_string);
  865. #endif
  866.  
  867.     if (status < 18 && status >2 ) {    /* We aren't closed yet ! */
  868. #ifdef    NET_DEBUG
  869.         sprintf(net_debug_string, "TCPClose being attempted state ...[%d]",status); /* Prolly because outstanding close */
  870.         net_debug_print(net_debug_string);
  871. #endif
  872.         clearPB( pbp, TCPd, TCPClose, p->stream);            /* Make Close call */
  873.         if ((errorCode=xPBControlAsync(pbp, (TCPIOCompletionProc)CloseCompleteInitUPP)) != noError) 
  874.             {            /* TCP close failed */
  875.             DoError(517 | NET_ERRORCLASS, LEVEL2, "Mnetclose");
  876.             return (errorCode);
  877.             }
  878.  
  879.         /* Go ahead and return... PB is in use by Async Close call. */
  880.         return (0);                                            /* Return with OK */
  881.         }
  882.  
  883.     /* IF we got here, we must be at closed state, so free memory */
  884.  
  885. #ifdef    NET_DEBUG
  886.     sprintf(net_debug_string, "TCP being released, status = %d", status);
  887.     net_debug_print(net_debug_string);
  888. #endif
  889.  
  890.     clearPB( pbp,TCPd, TCPRelease, p->stream);            /* Make Release call */
  891.     if (xPBControlSync(pbp) != noError) 
  892.         {                /* TCP failed to be released.  Let us know... */
  893.         DoError (518 | NET_ERRORCLASS, LEVEL2, "Mnetclose");
  894.         return (-1);
  895.         }
  896.     
  897.     DisposPtr( p->buffer);                /* Free Receive Buffer */
  898.     DisposPtr( p->sbuffer);                /* Free Send Buffer */
  899.     DisposPtr((Ptr) p);                    /* Free Stream Structure */
  900.     streams[pnum]=0L;
  901.     netportencryptstate(pnum, 0);
  902.  
  903.     MyPBreturn(pbp);
  904.     return(0);
  905. }
  906.  
  907. /**************************************************************************/
  908. /*    Nuke the connection, NOW! */
  909. short    netabort(short pnum)
  910. {
  911.     StreamRPtr    p;
  912.     MyTCPpbPtr    pbp;
  913.     OSErr        errorCode = noErr;
  914.  
  915.     if (pnum < 0 || pnum >= NPORTS)            /* is a valid port? */
  916.         return(-1);
  917.  
  918.     if ((p = streams[pnum]) != NULL)     /* something there */
  919.         {            
  920.         pbp=getPB( TCPd, TCPAbort, p->stream, 12);            /* Make Close call */
  921.         if ((errorCode=xPBControlSync(pbp)) != noError)         /* TCP abort failed.  Bad news */
  922.             DoError (519 | NET_ERRORCLASS, LEVEL1, NULL);
  923.         clearPB( pbp,TCPd, TCPRelease, p->stream);            /* Make Close call */
  924.         if (xPBControlSync(pbp) != noError) 
  925.             {
  926.             DoError (518 | NET_ERRORCLASS, LEVEL2, NULL);
  927.             return(-1);
  928.             }
  929.         }
  930.     else
  931.         return(1);
  932.     
  933.     DisposPtr( p->buffer);                /* Free Receive Buffer */
  934.     DisposPtr( p->sbuffer);                /* Free Send Buffer */
  935.     DisposPtr((Ptr) p);                    /* Free Stream Structure */
  936.     streams[pnum]=0L;
  937.  
  938.     MyPBreturn(pbp);
  939.     return(0);
  940. }
  941.  
  942.  
  943. /**************************************************************************/
  944. /*  Mnetinit
  945. *   Calls all of the various initialization routines that set up queueing
  946. *   variables, static values, reads configuration files, etc.
  947. */
  948.  
  949. void Mnetinit( void)
  950. {
  951.     short    i;
  952.     OSErr    err;
  953.  
  954. #ifndef __powerpc__    
  955.     MyA5 = SetCurrentA5();
  956. #endif
  957.     
  958.     for (i=0; i<NPORTS;i++) {
  959.         streams[i]= (StreamRPtr) 0;
  960.         SetPortType(i, NO_TYPE);
  961.         } 
  962.         
  963.     gFreePBQueue.qHead = NULL;
  964.     gFreePBQueue.qTail = NULL;
  965.     gFreePBQueue.qFlags = 0;
  966.     gFreeSWDSQueue.qHead = NULL;
  967.     gFreeSWDSQueue.qTail = NULL;
  968.     gFreeSWDSQueue.qFlags = 0;
  969.         
  970.     if ((err = OpenDriver("\p.IPP",&TCPd)) != noError)         /* cant open the IP driver */
  971.         {    
  972.         SetCursor(theCursors[normcurs]);
  973.         FatalAlert(CANT_OPEN_MACTCP, 300, err);        // Doesn't return!
  974.         }
  975. }
  976.  
  977.  
  978.  
  979. /*************************************************************************/
  980. /*  Mnetshut
  981. *   Close all the connections and turn off the hardware.
  982. */
  983. void netshut(void)
  984. {
  985.     short    i;
  986.  
  987.     for (i=0; i < NPORTS ; i++) 
  988.         if (streams[i] != (StreamRPtr) NULL)
  989.             netabort(i);                        /* Prolly should abort */
  990. }
  991.  
  992. /**************************************************************************/
  993. short    findbystream(StreamPtr streamPtr)
  994. {
  995.     short    pnum=0;
  996.     
  997.     while (pnum<NPORTS &&
  998.             ( (streams[pnum] ==(StreamRPtr)0L) || (streamPtr !=streams[pnum]->stream)))
  999.         pnum++;
  1000.     if (pnum >=NPORTS)
  1001.         return(-1);
  1002.     else
  1003.         return(pnum);
  1004. }
  1005.  
  1006.  
  1007. /**************************************************************************/
  1008. SIMPLE_UPP(Notify, TCPNotify);
  1009. pascal void Notify(StreamPtr streamPtr, unsigned short code, Ptr uptr, 
  1010.                         unsigned short terminReason, struct ICMPReport *icmpMsg)
  1011. {
  1012.     #pragma unused(uptr, terminReason, icmpMsg)
  1013.     StreamRPtr    p;
  1014.     short        pnum;
  1015.     
  1016.     pnum = findbystream(streamPtr);
  1017.     
  1018.     if (pnum < 0 || (p = streams[pnum]) == 0L)
  1019.         return;
  1020.     
  1021.     switch( code) {
  1022.         case TCPTerminate:
  1023.         case TCPClosing:
  1024.             netputevent(CONCLASS, CONCLOSE, pnum,0);
  1025.             break;
  1026.         case TCPULPTimeout:
  1027.             netputevent(CONCLASS, CONFAIL, pnum,0);
  1028.             break;
  1029.         case TCPDataArrival:
  1030.         case TCPUrgent:
  1031.             netputuev(CONCLASS, CONDATA, pnum,0);
  1032.             break;
  1033.         case TCPICMPReceived:
  1034.         default:
  1035.             break;
  1036.         }
  1037.     return;
  1038. }
  1039.  
  1040. /**************************************************************************/
  1041. SIMPLE_UPP(OpenCompleteInit, TCPIOCompletion);
  1042. TCPIOCompletionProc OpenCompleteInit(TCPiopb *pbp)
  1043. {
  1044.     long        saveA5;
  1045.     MyTCPpbPtr    myptr;
  1046.     
  1047.     myptr = (MyTCPpbPtr)pbp;
  1048.  
  1049. #ifndef _powerpc_
  1050.     saveA5 = SetA5(myptr->SavedA5);
  1051. #endif
  1052.  
  1053.     OpenComplete(myptr);
  1054.  
  1055. #ifndef _powerpc_
  1056.     SetA5(saveA5);
  1057. #endif
  1058. }
  1059.  
  1060. /**************************************************************************/
  1061. void    OpenComplete(MyTCPpbPtr pbp)
  1062. {
  1063.     StreamRPtr    p;
  1064.     short        pnum;
  1065.  
  1066.     pnum= findbystream(pbp->pb.tcpStream);
  1067.     
  1068.     if (pnum < 0 || (p = streams[pnum]) == 0L) 
  1069.         MyPBreturn(pbp);
  1070.         
  1071.     if (pbp->pb.ioResult !=noError) 
  1072.         netputevent(CONCLASS, CONFAIL, pnum,0);            /* Failure ... */
  1073.     else 
  1074.         netputevent(CONCLASS, CONOPEN, pnum,0);            /* Success ! */
  1075.  
  1076.     MyPBreturn( pbp);
  1077. }
  1078.  
  1079. /**************************************************************************/
  1080. void    SendComplete(MyTCPpbPtr pbp)
  1081. {
  1082.     StreamRPtr    p;
  1083.     short        pnum;
  1084.     wdsEntry    *swds;
  1085.  
  1086.     swds = (wdsEntry *) pbp->pb.csParam.send.wdsPtr;
  1087.     
  1088.     pnum = findbystream(pbp->pb.tcpStream);
  1089.     
  1090.     if (pnum < 0 || (p = streams[pnum]) == 0L) {
  1091.         MyPBreturn(pbp);
  1092.         return;
  1093.         }
  1094.         
  1095.     MyPBreturn( pbp);
  1096.     giveback( p, (wdsEntry *) pbp->pb.csParam.send.wdsPtr);    /* BYU LSC - Give this back.... NOW */
  1097.     returnSWDS( swds);
  1098. }
  1099.  
  1100.  
  1101. /**************************************************************************/
  1102. SIMPLE_UPP(SendCompleteInit, TCPIOCompletion);
  1103. TCPIOCompletionProc SendCompleteInit(TCPiopb *pbp)
  1104. {
  1105.     long        saveA5;
  1106.     MyTCPpbPtr    myptr;
  1107.     
  1108.     myptr = (MyTCPpbPtr)pbp;
  1109.  
  1110. #ifndef _powerpc_
  1111.     saveA5 = SetA5(myptr->SavedA5);
  1112. #endif
  1113.     
  1114.     SendComplete(myptr);
  1115.     
  1116. #ifndef _powerpc_
  1117.     SetA5(saveA5);
  1118. #endif
  1119. }
  1120.  
  1121. /**************************************************************************/
  1122. void    CloseComplete(MyTCPpbPtr pbp)
  1123. {
  1124.     StreamRPtr    p;
  1125.     short        pnum;
  1126.  
  1127.     pnum= findbystream(pbp->pb.tcpStream);
  1128.     
  1129.     if (pnum < 0 || (p = streams[pnum]) == 0L)
  1130.       {
  1131.         netputevent(SCLASS, CLOSEDONE+1, pnum,0);
  1132.         MyPBreturn(pbp);
  1133.         return;
  1134.       }
  1135.         
  1136.     if (pbp->pb.ioResult !=noError) 
  1137.         netputevent(SCLASS, CLOSEDONE+1, pnum,0);
  1138.     else 
  1139.         netputevent(SCLASS, CLOSEDONE, pnum,0);            /* Success ! */
  1140.  
  1141.     MyPBreturn( pbp);
  1142. }
  1143.  
  1144. /**************************************************************************/
  1145. SIMPLE_UPP(CloseCompleteInit, TCPIOCompletion);
  1146. TCPIOCompletionProc CloseCompleteInit(TCPiopb *pbp)
  1147. {
  1148.     long        saveA5;
  1149.     MyTCPpbPtr    myptr;
  1150.     
  1151.     myptr = (MyTCPpbPtr)pbp;
  1152.  
  1153. #ifndef _powerpc_
  1154.     saveA5 = SetA5(myptr->SavedA5);
  1155. #endif
  1156.     
  1157.     CloseComplete(myptr);
  1158.     
  1159. #ifndef _powerpc_
  1160.     SetA5(saveA5);
  1161. #endif
  1162. }
  1163.  
  1164. short netportencryptstate (short port, Ptr edata)
  1165. {
  1166.     StreamRPtr    p;
  1167.  
  1168.     if (port < 0 || port >= NPORTS)
  1169.          return(-2);
  1170.  
  1171.      if ((p = streams[port]) == NULL)
  1172.          return(-2);
  1173.  
  1174.      p->edata = edata;
  1175.  
  1176.      return 0;
  1177. }
  1178.